Python SQLAlchemy Session Management: Transaktionsverarbeitung zur Sicherstellung der Datenintegrität meistern

SQLAlchemy ist eine leistungsstarke und flexible Python-Bibliothek, die ein umfassendes Toolkit für die Interaktion mit Datenbanken bietet. Im Mittelpunkt von SQLAlchemy steht das Konzept der Session, die als Staging-Bereich für alle Operationen dient, die Sie an Ihrer Datenbank durchführen. Ein angemessenes Session- und Transaktionsmanagement ist entscheidend für die Aufrechterhaltung der Datenintegrität und die Gewährleistung eines konsistenten Datenbankverhaltens, insbesondere in komplexen Anwendungen, die gleichzeitige Anfragen verarbeiten.

SQLAlchemy-Sessions verstehen

Eine SQLAlchemy-Session repräsentiert eine Arbeitseinheit, eine Konversation mit der Datenbank. Sie verfolgt Änderungen, die an Objekten vorgenommen wurden, und ermöglicht es Ihnen, diese als einzelne atomare Operation in der Datenbank zu speichern. Stellen Sie sich dies als einen Arbeitsbereich vor, in dem Sie Änderungen an Daten vornehmen, bevor Sie diese offiziell speichern. Ohne eine gut verwaltete Session riskieren Sie Dateninkonsistenzen und potenzielle Beschädigungen.

Erstellen einer Session

Bevor Sie mit Ihrer Datenbank interagieren können, müssen Sie eine Session erstellen. Dies beinhaltet zunächst den Aufbau einer Verbindung zur Datenbank mit der SQLAlchemy-Engine.

            from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

# Datenbank-Verbindungszeichenfolge
db_url = 'sqlite:///:memory:'  # Ersetzen Sie dies durch Ihre Datenbank-URL (z.B. PostgreSQL, MySQL)

# Erstellen einer Engine
engine = create_engine(db_url, echo=False) # echo=True, um die generierten SQL-Anweisungen anzuzeigen

# Definieren einer Basis für deklarative Modelle
Base = declarative_base()

# Definieren eines einfachen Modells
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String)

    def __repr__(self):
        return f""

# Erstellen der Tabelle in der Datenbank
Base.metadata.create_all(engine)

# Erstellen einer Session-Klasse
Session = sessionmaker(bind=engine)

# Instanziieren einer Session
session = Session()

            

              
                Copy
              
            
          

In diesem Beispiel:

• Wir importieren die notwendigen SQLAlchemy-Module.
• Wir definieren eine Datenbank-Verbindungszeichenfolge (`db_url`). Dieses Beispiel verwendet eine In-Memory-SQLite-Datenbank zur Vereinfachung, aber Sie würden sie durch eine Verbindungszeichenfolge ersetzen, die für Ihr Datenbanksystem geeignet ist (z. B. PostgreSQL, MySQL). Das spezifische Format variiert je nach Datenbank-Engine und -Treiber, den Sie verwenden. Konsultieren Sie die SQLAlchemy-Dokumentation und die Dokumentation Ihres Datenbankanbieters für das korrekte Verbindungszeichenfolgenformat.
• Wir erstellen eine `Engine` mit `create_engine()`. Die Engine ist für die Verwaltung des Verbindungspools und die Kommunikation mit der Datenbank verantwortlich. Der Parameter `echo=True` kann zum Debuggen hilfreich sein, da er die generierten SQL-Anweisungen in der Konsole ausgibt.
• Wir definieren eine Basisklasse (`Base`) mit `declarative_base()`. Diese wird als Basisklasse für alle unsere SQLAlchemy-Modelle verwendet.
• Wir definieren ein `User`-Modell und ordnen es einer Datenbanktabelle namens `users` zu.
• Wir erstellen die Tabelle in der Datenbank mit `Base.metadata.create_all(engine)`.
• Wir erstellen eine Session-Klasse mit `sessionmaker(bind=engine)`. Dies konfiguriert die Session-Klasse so, dass sie die angegebene Engine verwendet.
• Schließlich instanziieren wir eine Session mit `Session()`.

Transaktionen verstehen

Eine Transaktion ist eine Abfolge von Datenbankoperationen, die als einzelne logische Arbeitseinheit behandelt werden. Transaktionen halten sich an die ACID-Eigenschaften:

• Atomarität: Entweder alle Operationen in der Transaktion sind vollständig erfolgreich oder schlagen vollständig fehl. Wenn ein Teil der Transaktion fehlschlägt, wird die gesamte Transaktion zurückgesetzt.
• Konsistenz: Die Transaktion muss die Datenbank in einem gültigen Zustand halten. Sie darf keine Datenbankbeschränkungen oder -regeln verletzen.
• Isolation: Gleichzeitige Transaktionen sind voneinander isoliert. Änderungen, die von einer Transaktion vorgenommen werden, sind für andere Transaktionen erst sichtbar, wenn die erste Transaktion abgeschlossen ist.
• Dauerhaftigkeit: Sobald eine Transaktion abgeschlossen ist, sind ihre Änderungen dauerhaft und überstehen auch Systemausfälle.

SQLAlchemy bietet Mechanismen zur Verwaltung von Transaktionen, um sicherzustellen, dass diese ACID-Eigenschaften eingehalten werden.

Grundlegende Transaktionsverarbeitung

Die häufigsten Transaktionsoperationen sind Commit und Rollback.

Transaktionen abschließen (Commit)

Wenn alle Operationen innerhalb einer Transaktion erfolgreich abgeschlossen wurden, committen Sie die Transaktion. Dadurch werden die Änderungen in der Datenbank gespeichert.

            try:
    # Hinzufügen eines neuen Benutzers
    new_user = User(name='Alice Smith', email='alice.smith@example.com')
    session.add(new_user)

    # Commit der Transaktion
    session.commit()
    print("Transaktion erfolgreich abgeschlossen!")

except Exception as e:
    # Ausnahmebehandlung
    print(f"Ein Fehler ist aufgetreten: {e}")
    session.rollback()
    print("Transaktion zurückgesetzt.")

finally:
    session.close()

            

              
                Copy
              
            
          

In diesem Beispiel:

• Wir fügen der Session ein neues `User`-Objekt hinzu.
• Wir rufen `session.commit()` auf, um die Änderungen in der Datenbank zu speichern.
• Wir umschließen den Code mit einem `try...except...finally`-Block, um potenzielle Ausnahmen zu behandeln.
• Wenn eine Ausnahme auftritt, rufen wir `session.rollback()` auf, um alle während der Transaktion vorgenommenen Änderungen rückgängig zu machen.
• Wir rufen immer `session.close()` im `finally`-Block auf, um die Session freizugeben und die Verbindung an den Verbindungspool zurückzugeben. Dies ist entscheidend, um Ressourcenlecks zu vermeiden. Wenn Sessions nicht geschlossen werden, kann dies zu Verbindungserschöpfung und Anwendungsinstabilität führen.

Transaktionen zurücksetzen (Rollback)

Wenn während einer Transaktion ein Fehler auftritt oder Sie entscheiden, dass die Änderungen nicht gespeichert werden sollen, setzen Sie die Transaktion zurück. Dadurch wird die Datenbank in den Zustand vor Beginn der Transaktion zurückversetzt.

            try:
    # Hinzufügen eines Benutzers mit einer ungültigen E-Mail-Adresse (Beispiel, um einen Rollback zu erzwingen)
    invalid_user = User(name='Bob Johnson', email='invalid-email')
    session.add(invalid_user)

    # Der Commit schlägt fehl, wenn die E-Mail-Adresse nicht auf Datenbankebene validiert wird
    session.commit()
    print("Transaktion abgeschlossen.")

except Exception as e:
    print(f"Ein Fehler ist aufgetreten: {e}")
    session.rollback()
    print("Transaktion erfolgreich zurückgesetzt.")

finally:
    session.close()

            

              
                Copy
              
            
          

In diesem Beispiel wird durch den Aufruf von `session.rollback()` der versuchte Einfügevorgang rückgängig gemacht, sodass die Datenbank unverändert bleibt, wenn das Hinzufügen von `invalid_user` eine Ausnahme auslöst (z. B. aufgrund einer Datenbankbeschränkungsverletzung).

Erweiterte Transaktionsverwaltung

Verwenden der `with`-Anweisung für Transaktionsbereich

Eine Pythonischere und robustere Möglichkeit, Transaktionen zu verwalten, ist die Verwendung der `with`-Anweisung. Dadurch wird sichergestellt, dass die Session ordnungsgemäß geschlossen wird, auch wenn Ausnahmen auftreten.

            from contextlib import contextmanager

@contextmanager
def session_scope():
    """Bereitstellen eines Transaktionsbereichs für eine Reihe von Operationen."""
    session = Session()
    try:
        yield session
        session.commit()
    except Exception:
        session.rollback()
        raise
    finally:
        session.close()

# Verwendung:
with session_scope() as session:
    new_user = User(name='Charlie Brown', email='charlie.brown@example.com')
    session.add(new_user)
    # Operationen innerhalb des 'with'-Blocks
    # Wenn keine Ausnahmen auftreten, wird die Transaktion automatisch abgeschlossen.
    # Wenn eine Ausnahme auftritt, wird die Transaktion automatisch zurückgesetzt.
    print("Benutzer hinzugefügt.")

print("Transaktion abgeschlossen (abgeschlossen oder zurückgesetzt).")

            

              
                Copy
              
            
          

Die Funktion `session_scope` ist ein Kontextmanager. Wenn Sie den `with`-Block betreten, wird eine neue Session erstellt. Wenn Sie den `with`-Block verlassen, wird die Session entweder abgeschlossen (wenn keine Ausnahmen aufgetreten sind) oder zurückgesetzt (wenn eine Ausnahme aufgetreten ist). Die Session wird immer im `finally`-Block geschlossen.

Geschachtelte Transaktionen (Savepoints)

SQLAlchemy unterstützt geschachtelte Transaktionen mithilfe von Savepoints. Ein Savepoint ermöglicht es Ihnen, zu einem bestimmten Punkt innerhalb einer größeren Transaktion zurückzukehren, ohne die gesamte Transaktion zu beeinträchtigen.

            try:
    with session_scope() as session:
        user1 = User(name='David Lee', email='david.lee@example.com')
        session.add(user1)
        session.flush()  # Senden von Änderungen an die Datenbank, aber noch kein Commit

        # Erstellen eines Savepoints
        savepoint = session.begin_nested()

        try:
            user2 = User(name='Eve Wilson', email='eve.wilson@example.com')
            session.add(user2)
            session.flush()

            # Simulieren eines Fehlers
            raise ValueError("Simulierter Fehler während der geschachtelten Transaktion")

        except Exception as e:
            print(f"Fehler bei der geschachtelten Transaktion: {e}")
            savepoint.rollback()
            print("Geschachtelte Transaktion auf Savepoint zurückgesetzt.")

        # Fortsetzen der äußeren Transaktion, user1 wird weiterhin hinzugefügt
        user3 = User(name='Frank Miller', email='frank.miller@example.com')
        session.add(user3)

except Exception as e:
    print(f"Fehler bei der äußeren Transaktion: {e}")


#Commit committet user1 und user3, aber nicht user2 aufgrund des geschachtelten Rollbacks

try:
    with session_scope() as session:
        #Überprüfen, ob nur user1 und user3 existieren
        users = session.query(User).all()
        for user in users:
            print(user)
except Exception as e:
    print(f"Unerwartete Ausnahme: {e}") #Sollte nicht passieren

            

              
                Copy
              
            
          

In diesem Beispiel:

• Wir starten eine äußere Transaktion mit `session_scope()`.
• Wir fügen `user1` zur Session hinzu und übertragen die Änderungen an die Datenbank. `flush()` sendet die Änderungen an den Datenbankserver, führt aber *keinen* Commit durch. So können Sie vor dem Commit der gesamten Transaktion prüfen, ob die Änderungen gültig sind (z. B. keine Beschränkungsverletzungen).
• Wir erstellen einen Savepoint mit `session.begin_nested()`.
• Innerhalb der geschachtelten Transaktion fügen wir `user2` hinzu und simulieren einen Fehler.
• Wir setzen die geschachtelte Transaktion mit `savepoint.rollback()` auf den Savepoint zurück. Dadurch werden nur die Änderungen rückgängig gemacht, die innerhalb der geschachtelten Transaktion vorgenommen wurden (d. h. das Hinzufügen von `user2`).
• Wir setzen die äußere Transaktion fort und fügen `user3` hinzu.
• Die äußere Transaktion wird committet, wodurch `user1` und `user3` in der Datenbank gespeichert werden, während `user2` aufgrund des Savepoint-Rollbacks verworfen wird.

Kontrollieren der Isolationsstufen

Isolationsstufen definieren den Grad, in dem gleichzeitige Transaktionen voneinander isoliert sind. Höhere Isolationsstufen bieten eine größere Datenkonsistenz, können aber die Nebenläufigkeit und Leistung reduzieren. SQLAlchemy ermöglicht es Ihnen, die Isolationsstufe Ihrer Transaktionen zu steuern.

Zu den üblichen Isolationsstufen gehören:

• Read Uncommitted: Die niedrigste Isolationsstufe. Transaktionen können nicht abgeschlossene Änderungen sehen, die von anderen Transaktionen vorgenommen wurden. Dies kann zu Dirty Reads führen.
• Read Committed: Transaktionen können nur abgeschlossene Änderungen sehen, die von anderen Transaktionen vorgenommen wurden. Dies verhindert Dirty Reads, kann aber zu Non-Repeatable Reads und Phantom Reads führen.
• Repeatable Read: Transaktionen können während der gesamten Transaktion dieselben Daten sehen, auch wenn andere Transaktionen sie ändern. Dies verhindert Dirty Reads und Non-Repeatable Reads, kann aber zu Phantom Reads führen.
• Serializable: Die höchste Isolationsstufe. Transaktionen sind vollständig voneinander isoliert. Dies verhindert Dirty Reads, Non-Repeatable Reads und Phantom Reads, kann aber die Nebenläufigkeit erheblich reduzieren.

Die Standardisolationsstufe hängt vom Datenbanksystem ab. Sie können die Isolationsstufe beim Erstellen der Engine oder beim Starten einer Transaktion festlegen.

Beispiel (PostgreSQL):

            from sqlalchemy.dialects.postgresql import dialect

# Festlegen der Isolationsstufe beim Erstellen der Engine
engine = create_engine('postgresql://user:password@host:port/database',
                       connect_args={'options': '-c statement_timeout=1000'} #Beispiel für Timeout
                      )

# Festlegen der Isolationsstufe beim Starten einer Transaktion (datenbankspezifisch)
# Für PostgreSQL wird empfohlen, sie auf der Verbindung und nicht auf der Engine festzulegen.

from sqlalchemy import event
from sqlalchemy.pool import Pool

@event.listens_for(Pool, "connect")
def set_isolation_level(dbapi_connection, connection_record):
    existing_autocommit = dbapi_connection.autocommit
    dbapi_connection.autocommit = True
    cursor = dbapi_connection.cursor()
    cursor.execute("SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE")
    dbapi_connection.autocommit = existing_autocommit
    cursor.close()


# Dann verwenden Transaktionen, die über SQLAlchemy erstellt wurden, die konfigurierte Isolationsstufe.

            

              
                Copy
              
            
          

Wichtig: Die Methode zum Festlegen von Isolationsstufen ist datenbankspezifisch. Informationen zur korrekten Syntax finden Sie in der Dokumentation Ihrer Datenbank. Das falsche Festlegen von Isolationsstufen kann zu unerwartetem Verhalten oder Fehlern führen.

Behandeln von Nebenläufigkeit

Wenn mehrere Benutzer oder Prozesse gleichzeitig auf dieselben Daten zugreifen, ist es wichtig, die Nebenläufigkeit ordnungsgemäß zu behandeln, um Datenbeschädigungen zu vermeiden und die Datenkonsistenz sicherzustellen. SQLAlchemy bietet verschiedene Mechanismen zur Behandlung von Nebenläufigkeit, darunter Optimistic Locking und Pessimistic Locking.

Optimistic Locking

Optimistic Locking geht davon aus, dass Konflikte selten sind. Es prüft vor dem Commit einer Transaktion, ob Änderungen von anderen Transaktionen vorgenommen wurden. Wenn ein Konflikt erkannt wird, wird die Transaktion zurückgesetzt.

Um Optimistic Locking zu implementieren, fügen Sie Ihrer Tabelle in der Regel eine Versionsspalte hinzu. Diese Spalte wird automatisch erhöht, wenn die Zeile aktualisiert wird.

            from sqlalchemy import Column, Integer, String, Integer
from sqlalchemy.orm import declarative_base

Base = declarative_base()

class Article(Base):
    __tablename__ = 'articles'
    id = Column(Integer, primary_key=True)
    title = Column(String)
    content = Column(String)
    version = Column(Integer, nullable=False, default=1)

    def __repr__(self):
        return f""

#Innerhalb des Try-Catch-Blocks

def update_article(session, article_id, new_content):
    article = session.query(Article).filter_by(id=article_id).first()

    if article is None:
        raise ValueError("Artikel nicht gefunden")

    original_version = article.version

    # Aktualisieren des Inhalts und Erhöhen der Version
    article.content = new_content
    article.version += 1

    # Versuchen, zu aktualisieren, wobei die Spalte "version" in der WHERE-Klausel überprüft wird
    rows_affected = session.query(Article).filter(
        Article.id == article_id,
        Article.version == original_version
    ).update({
        Article.content: new_content,
        Article.version: article.version
    }, synchronize_session=False)

    if rows_affected == 0:
        session.rollback()
        raise ValueError("Konflikt: Artikel wurde von einer anderen Transaktion aktualisiert.")
    
    session.commit()

            

              
                Copy
              
            
          

In diesem Beispiel:

• Wir fügen dem `Article`-Modell eine `version`-Spalte hinzu.
• Vor dem Aktualisieren des Artikels speichern wir die aktuelle Versionsnummer.
• In der `UPDATE`-Anweisung fügen wir eine `WHERE`-Klausel hinzu, die prüft, ob die Spalte "version" noch mit der gespeicherten Versionsnummer übereinstimmt. `synchronize_session=False` verhindert, dass SQLAlchemy das aktualisierte Objekt erneut lädt. Wir verarbeiten die Versionierung explizit.
• Wenn die Spalte "version" von einer anderen Transaktion geändert wurde, wirkt sich die `UPDATE`-Anweisung nicht auf Zeilen aus (rows_affected ist 0), und wir lösen eine Ausnahme aus.
• Wir setzen die Transaktion zurück und benachrichtigen den Benutzer, dass ein Konflikt aufgetreten ist.

Pessimistic Locking

Pessimistic Locking geht davon aus, dass Konflikte wahrscheinlich sind. Es erwirbt eine Sperre für eine Zeile oder Tabelle, bevor es sie ändert. Dies verhindert, dass andere Transaktionen die Daten ändern, bis die Sperre freigegeben wird.

SQLAlchemy bietet verschiedene Funktionen zum Erwerben von Sperren, z. B. `with_for_update()`.

            # Beispiel mit PostgreSQL
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base

# Datenbank-Setup (ersetzen Sie dies durch Ihre tatsächliche Datenbank-URL)
db_url = 'postgresql://user:password@host:port/database'
engine = create_engine(db_url, echo=False) #Set echo to true if you would like to see the SQL generated
Base = declarative_base()

class Item(Base):
    __tablename__ = 'items'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    value = Column(Integer)

    def __repr__(self):
        return f""

Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)

#Funktion zum Aktualisieren des Artikels (innerhalb eines Try/Except)
def update_item_value(session, item_id, new_value):
    # Erwerben einer pessimistischen Sperre für den Artikel
    item = session.query(Item).filter(Item.id == item_id).with_for_update().first()

    if item is None:
        raise ValueError("Artikel nicht gefunden")

    # Aktualisieren des Werts des Artikels
    item.value = new_value
    session.commit()
    return True

            

              
                Copy
              
            
          

In diesem Beispiel:

• Wir verwenden `with_for_update()`, um eine Sperre für die `Item`-Zeile zu erwerben, bevor wir sie aktualisieren. Dies verhindert, dass andere Transaktionen die Zeile ändern, bis die aktuelle Transaktion abgeschlossen oder zurückgesetzt wird. Die Funktion `with_for_update()` ist datenbankspezifisch. Einzelheiten finden Sie in der Dokumentation Ihrer Datenbank. Einige Datenbanken verfügen möglicherweise über andere Sperrmechanismen oder -syntaxen.

Wichtig: Pessimistic Locking kann die Nebenläufigkeit und Leistung reduzieren, verwenden Sie es daher nur, wenn es erforderlich ist.

Best Practices für die Ausnahmebehandlung

Eine ordnungsgemäße Ausnahmebehandlung ist entscheidend, um die Datenintegrität sicherzustellen und Anwendungsabstürze zu verhindern. Umschließen Sie Ihre Datenbankoperationen immer mit `try...except`-Blöcken und behandeln Sie Ausnahmen entsprechend.

Hier sind einige Best Practices für die Ausnahmebehandlung:

• Fangen Sie bestimmte Ausnahmen ab: Vermeiden Sie das Abfangen generischer Ausnahmen wie `Exception`. Fangen Sie bestimmte Ausnahmen wie `sqlalchemy.exc.IntegrityError` oder `sqlalchemy.exc.OperationalError` ab, um verschiedene Fehlertypen unterschiedlich zu behandeln.
• Transaktionen zurücksetzen: Setzen Sie die Transaktion immer zurück, wenn eine Ausnahme auftritt.
• Protokollieren Sie Ausnahmen: Protokollieren Sie Ausnahmen, um Probleme zu diagnostizieren und zu beheben. Fügen Sie Ihren Protokollen so viele Kontextinformationen wie möglich hinzu (z. B. die Benutzer-ID, die Eingabedaten, den Zeitstempel).
• Lösen Sie Ausnahmen bei Bedarf erneut aus: Wenn Sie eine Ausnahme nicht behandeln können, lösen Sie sie erneut aus, damit ein Handler höherer Ebene sie behandeln kann.
• Bereinigen Sie Ressourcen: Schließen Sie immer die Session und geben Sie alle anderen Ressourcen in einem `finally`-Block frei.

            import logging
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker, declarative_base
from sqlalchemy.exc import IntegrityError, OperationalError

# Konfigurieren der Protokollierung
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Datenbank-Setup (ersetzen Sie dies durch Ihre tatsächliche Datenbank-URL)
db_url = 'postgresql://user:password@host:port/database'
engine = create_engine(db_url, echo=False)
Base = declarative_base()

class Product(Base):
    __tablename__ = 'products'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    price = Column(Integer)

    def __repr__(self):
        return f""

Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)

# Funktion zum Hinzufügen eines Produkts
def add_product(session, name, price):
    try:
        new_product = Product(name=name, price=price)
        session.add(new_product)
        session.commit()
        logging.info(f"Produkt '{name}' erfolgreich hinzugefügt.")
        return True
    except IntegrityError as e:
        session.rollback()
        logging.error(f"IntegrityError: {e}")
        #Behandeln von Datenbankbeschränkungsverletzungen (z. B. doppelter Name)
        return False
    except OperationalError as e:
        session.rollback()
        logging.error(f"OperationalError: {e}")
        #Behandeln von Verbindungsfehlern oder anderen betrieblichen Problemen
        return False
    except Exception as e:
        session.rollback()
        logging.exception(f"Ein unerwarteter Fehler ist aufgetreten: {e}")
        # Behandeln aller anderen unerwarteten Fehler
        return False
    finally:
        session.close()

            

              
                Copy
              
            
          

In diesem Beispiel:

• Wir konfigurieren die Protokollierung, um Ereignisse während des Prozesses aufzuzeichnen.
• Wir fangen bestimmte Ausnahmen wie `IntegrityError` (für Beschränkungsverletzungen) und `OperationalError` (für Verbindungsfehler) ab.
• Wir setzen die Transaktion in den `except`-Blöcken zurück.
• Wir protokollieren die Ausnahmen mit dem `logging`-Modul. Die Methode `logging.exception()` fügt der Protokollnachricht automatisch die Stack-Trace hinzu.
• Wir lösen die Ausnahme erneut aus, wenn wir sie nicht behandeln können.
• Wir schließen die Session im `finally`-Block.

Datenbank-Verbindungspooling

SQLAlchemy verwendet Verbindungspooling, um Datenbankverbindungen effizient zu verwalten. Ein Verbindungspool verwaltet einen Satz offener Verbindungen zur Datenbank, sodass Anwendungen vorhandene Verbindungen wiederverwenden können, anstatt für jede Anforderung neue Verbindungen zu erstellen. Dies kann die Leistung erheblich verbessern, insbesondere in Anwendungen, die eine große Anzahl gleichzeitiger Anforderungen verarbeiten.

Die Funktion `create_engine()` von SQLAlchemy erstellt automatisch einen Verbindungspool. Sie können den Verbindungspool konfigurieren, indem Sie Argumente an `create_engine()` übergeben.

Zu den üblichen Parametern des Verbindungspools gehören:

• pool_size: Die maximale Anzahl von Verbindungen im Pool.
• max_overflow: Die Anzahl der Verbindungen, die über die pool_size hinaus erstellt werden können.
• pool_recycle: Die Anzahl der Sekunden, nach denen eine Verbindung wiederverwendet wird.
• pool_timeout: Die Anzahl der Sekunden, die auf das Verfügbarwerden einer Verbindung gewartet werden soll.

            engine = create_engine('postgresql://user:password@host:port/database',
                       pool_size=5, #Maximale Poolgröße
                       max_overflow=10, #Maximaler Überlauf
                       pool_recycle=3600, #Verbindungen nach 1 Stunde wiederverwenden
                       pool_timeout=30
                      )

            

              
                Copy
              
            
          

Wichtig: Wählen Sie geeignete Einstellungen für den Verbindungspool basierend auf den Anforderungen Ihrer Anwendung und den Fähigkeiten Ihres Datenbankservers. Ein schlecht konfigurierter Verbindungspool kann zu Leistungsproblemen oder Verbindungserschöpfung führen.

Asynchrone Transaktionen (Async SQLAlchemy)

Für moderne Anwendungen, die eine hohe Nebenläufigkeit erfordern, insbesondere solche, die mit asynchronen Frameworks wie FastAPI oder AsyncIO erstellt wurden, bietet SQLAlchemy eine asynchrone Version namens Async SQLAlchemy.

Async SQLAlchemy bietet asynchrone Versionen der SQLAlchemy-Kernkomponenten, mit denen Sie Datenbankoperationen ausführen können, ohne die Ereignisschleife zu blockieren. Dies kann die Leistung und Skalierbarkeit Ihrer Anwendungen erheblich verbessern.

Hier ist ein grundlegendes Beispiel für die Verwendung von Async SQLAlchemy:

            from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import declarative_base
from sqlalchemy import Column, Integer, String
import asyncio

# Datenbank-Setup (ersetzen Sie dies durch Ihre tatsächliche Datenbank-URL)
db_url = 'postgresql+asyncpg://user:password@host:port/database'
engine = create_async_engine(db_url, echo=False)
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    email = Column(String)

    def __repr__(self):
        return f""

async def create_db_and_tables():
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)


async def add_user(name, email):
    async with AsyncSession(engine) as session:
        new_user = User(name=name, email=email)
        session.add(new_user)
        await session.commit()

async def main():
    await create_db_and_tables()
    await add_user("Async User", "async.user@example.com")

if __name__ == "__main__":
    asyncio.run(main())

            

              
                Copy
              
            
          

Wesentliche Unterschiede zu synchronem SQLAlchemy:

• `create_async_engine` wird anstelle von `create_engine` verwendet.
• `AsyncSession` wird anstelle von `Session` verwendet.
• Alle Datenbankoperationen sind asynchron und müssen mit `await` erwartet werden.
• Asynchrone Datenbanktreiber (z. B. `asyncpg` für PostgreSQL) müssen verwendet werden.

Wichtig: Async SQLAlchemy erfordert einen Datenbanktreiber, der asynchrone Operationen unterstützt. Stellen Sie sicher, dass Sie den richtigen Treiber installiert und konfiguriert haben.

Schlussfolgerung

Das Beherrschen des SQLAlchemy-Session- und Transaktionsmanagements ist unerlässlich, um robuste und zuverlässige Python-Anwendungen zu erstellen, die mit Datenbanken interagieren. Indem Sie die Konzepte von Sessions, Transaktionen, Isolationsstufen und Nebenläufigkeit verstehen und die Best Practices für die Ausnahmebehandlung und das Verbindungspooling befolgen, können Sie die Datenintegrität sicherstellen und die Leistung Ihrer Anwendungen optimieren.

Egal, ob Sie eine kleine Webanwendung oder ein großes Enterprise-System erstellen, SQLAlchemy bietet Ihnen die Tools, die Sie benötigen, um Ihre Datenbankinteraktionen effektiv zu verwalten. Denken Sie daran, immer der Datenintegrität Priorität einzuräumen und potenzielle Fehler elegant zu behandeln, um die Zuverlässigkeit Ihrer Anwendungen zu gewährleisten.

Erwägen Sie, erweiterte Themen wie die folgenden zu erkunden:

• Two-Phase Commit (2PC): Für Transaktionen, die sich über mehrere Datenbanken erstrecken.
• Sharding: Zum Verteilen von Daten auf mehrere Datenbankserver.
• Datenbankmigrationen: Verwenden von Tools wie Alembic, um Änderungen am Datenbankschema zu verwalten.